package handax.GUI;

import handax.controller.DBManager;
import handax.entities.Reservation;
import handax.entities.Restaurant;
import handax.entities.User;
import java.awt.Color;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.DefaultListModel;
import javax.swing.SwingUtilities;

/**
 *
 * @author Andreas Apostolidis
 * 
 * * ΚΑΤΑΣΤΑΣΕΙΣ ΚΡΑΤΗΣΕΙΣ
 * 1     ΑΝΕΝΕΓΡΗ (1)        ΧΡΩΜΑ  ΜΠΛΕ
 * 2     ΥΠΟΒΛΗΘΗΚΕ(2)       ΧΡΩΜΑ  ΓΑΛΑΖΙΟ
 * 2.1   ΛΙΣΤΑ ΑΝΑΜΟΝΗΣ(3)   ΧΡΩΜΑ  ΡΟΖ
 * 2.2   ΜΗ-ΔΙΑΘΕΣΙΜΗ(4)     ΧΡΩΜΑ  ΚΟΚΚΙΝΟ
 * 3     ΔΙΑΘΕΣΙΜΗ(5)        ΧΡΩΜΑ  ΚΙΤΡΙΝΟ
 * 3.1   ΕΓΚΡΙΣΗ ΚΡΑΤΗΣΗΣ(6) ΧΡΩΜΑ  ΠΡΑΣΙΝΟ ΑΝΟΙΚΤΟ
 * 3.2   ΑΚΥΡΩΘΗΚΕ(7)        ΧΡΩΜΑ  ΠΟΡΤΟΚΑΛΙ
 * 3.1.1 ΕΠΙΒΕΒΑΙΩΘΗΚΕ(8)    ΧΡΩΜΑ  ΠΡΑΣΙΝΟ 
 */
public class ReservSystem extends javax.swing.JFrame implements Runnable {

    private DBManager dBm;
    private ReservRest resView;
    private Reservation reservation;
    private boolean running = false;
    private boolean paused = false;
    private Thread thread = null;

    /** Creates new form ReservSystem */
    public ReservSystem(DBManager dBm) {
        this.dBm = dBm;
        initComponents();

        // αρχικοποίηση των λιστών για τις έγκυρες και μη-επιβεβαιωμένες κρατήσεις
        requestList.setModel(new ReservationRequestsListModel());
        confirmedList.setModel(new GeneralListModel());
        pendingList.setModel(new GeneralListModel());
    }
    //επιστρέφει την κράτηση

    public Reservation getReservation() {
        return reservation;
    }
    /*μέθοδος που χρησιμοποιείται στο κουμπί Αίτηση κράτησης
     * @params ένα αντικείμενο τύπου ReservRest(το παράθυρο των κρατήσεων)
     */

    public void setReservation(ReservRest reservationView) {
        this.resView = reservationView;
        //προσθέτει την αίτηση που δημιουργήσαμε στην λίστα των αίτησεων
        if (reservationView != null) {
            this.reservation = reservationView.getBooking();
            System.out.println("Received " + reservationView.getBooking());
            ReservationRequestsListModel model = (ReservationRequestsListModel) requestList.getModel();
            model.addReservation(reservation);
            //θέτει την κατάσταση και αλλάζει το χρώμα στο πάραθυρο της αίτησης
            reservationView.statusLabel.setText("ΥΠΟΒΛΗΘΗΚΕ");
            reservationView.statusPanel.setBackground(Color.CYAN);
        } else {
            reservation = null;
        }
    }
    /*μέθοδος που χρησιμοποιείται στο κουμπί Επιβεβαίωση κράτησης
     * @params ένα αντικείμενο τύπου ReservRest(το παράθυρο των κρατήσεων)
     */

    public void setConfirmedReservation(ReservRest reservationView) {
        this.resView = reservationView;
        //ενημερώνει την κατάσταση της κράτησης στην λίστα των μη-επιβεβαιωμένων σε ΕΓΚΡΙΣΗ ΚΡΑΤΗΣΗΣ
        if (reservationView != null) {
            this.reservation = reservationView.getBooking();
            System.out.println("Received confirmed resevation " + reservationView.getBooking());
            GeneralListModel model = (GeneralListModel) pendingList.getModel();
            model.removeReservation(reservation);
            model.addReservation(reservation);

            reservationView.statusLabel.setText("ΕΓΚΡΙΣΗ ΚΡΑΤΗΣΗΣ");
            reservationView.statusPanel.setBackground(new Color(204, 255, 204));
        } else {
            reservation = null;
        }
    }
    //επιστρέφει αν η υπηρεσία είναι σε παύση ή όχι

    public boolean isPaused() {
        return paused;
    }
    //η υλοποίηση της μεθόδου run του Runnable

    public void run() {

        running = true;

        try {
            final GeneralListModel gmodel = (GeneralListModel) confirmedList.getModel();
            final List<Reservation> confirmedReservations = retrieveAllComfirmedReservation();
            for (Reservation cr : confirmedReservations) {
                gmodel.addReservation(cr);
            }


            //όσο το running είναι true
            while (running) {
                //καλεσε την μέθοδο delay()(δημιουργεί ένα τυχαίο δίαστημα από 2-4sec που η υπηρεσία αδρανοποιείται
                delay();

                /*
                 * Δημιουργία τυχαίων κρατήσεων (βήμα α της εκφώνησης)
                 */
                System.out.println("(a)");
                /*το invokeAndWait συγχρονίζει και μπλοκάρει μεχρι να γίνουν οι αλλαγές που έχει μέσα η run του Runnable 
                 * που περιλαμβανει.
                 */

                SwingUtilities.invokeAndWait(new Runnable() {
                    /*εδω καλείται η generateUnconfirmedReservation που δημιουργεί τυχαίες κρατήσεις 
                     * και τις προσθέτει στην λίστα των αιτήσεων
                     */

                    public void run() {
                        ReservationRequestsListModel model = (ReservationRequestsListModel) requestList.getModel();


                        final List<Reservation> randomRequests = generateUnconfirmedReservations();


                        for (Reservation r : randomRequests) {
                            model.addReservation(r);
                        }

                        System.out.println("requestsList size: " + model.getSize());
                        requestList.updateUI();
                        confirmedList.updateUI();
                    }
                });


                /**
                 * Επεξεγρασία των αίτησεων (βήμα b της εκφώνησης)
                 */
                System.out.println("(b)");
                processSubmittedRequests();
                System.out.println("requestsList size (processed): " + requestList.getModel().getSize());
                delay();

                /**
                 * Επεξεργασία των μη-επιβεβαιωμένων κρατήσεων (βημα c της εκφώνησης)
                 */
                System.out.println("(c)");
                System.out.println("pendingList size: " + pendingList.getModel().getSize());
                processRequestsPendingApproval();
                System.out.println("pendingList size (processed): " + pendingList.getModel().getSize());
                delay();


                /**
                 * Επεξεργασία των αιτήσεων που έιναι σε κατάσταση ΛΙΣΤΑ ΑΝΑΜΟΝΗΣ (βήμα d της εκφώνησης)
                 */
                System.out.println("(d)");
                System.out.println("requestsList size: " + requestList.getModel().getSize());
                System.out.println("pendingList size: " + pendingList.getModel().getSize());
                processRequestsInAwaitingListStatus();
                System.out.println("pendingList size (processed): " + pendingList.getModel().getSize());
                System.out.println("requestsList size (processed): " + requestList.getModel().getSize());
                delay();

                /*
                 * Διαγραφή τυχαίων αιτήσεων από την λίστα επιβεβαιωμένων (βήμα e  της εκφώνησης)
                 */
                System.out.println("(e)");
                System.out.println("confirmedList size: " + confirmedList.getModel().getSize());
                deleteRandomNumOfComfirmedReservation();
                System.out.println("confirmedList size (after delete): " + confirmedList.getModel().getSize());
                System.out.println("------------------ End Of Cycle ---------------------\n");

                synchronized (this) {
                    while (paused) {
                        wait();
                    }
                }
            }
        } catch (InterruptedException ie) {
//            Logger.getLogger(ReservSystem.class.getName()).log(Level.SEVERE, null, ie);
            Thread.currentThread().interrupt();
        } catch (InvocationTargetException ite) {
//            Logger.getLogger(ReservSystem.class.getName()).log(Level.SEVERE, null, ite);
        }
    }
    //μεθοδος που ξεκινάει την υπρεσία

    public void start() {

        setVisible(true);

        while (!running) {
            thread = new Thread(this, "ReservationService");
            thread.start();
            System.out.println("Service started!");
        }
    }
    //μέθοδος που σταματάει την υοηρεσία

    public void stop() {
        running = false;
        setVisible(false);
        Thread test = thread;
        thread = null;
        test.interrupt();
        dispose();

        System.out.println("Service stopped!");
    }
    //μέθοδος που κάνει παύση στην υπηρεσία

    public void pause() {
        synchronized (this) {
            paused = true;
        }
        System.out.println("Service paused!");
    }
    //μέθοδος που κάνει resume της υπηρεσίας

    public void resume() {
        paused = false;
        synchronized (this) {
            notify();
        }
        System.out.println("Service resumed!");
    }

    /*μέθοδος για την δημιουργία τυχαίου αριθμού
     * @params int min int max (το διάστημα των αριθμών )
     * @returns int  τον τυχαίο αριθμό 
    /*/
    private int generateRandomNumber(int min, int max) {
        return (min + (int) (Math.random() * ((max - min) + 1)));
    }
    /*
     * μέθοδος που επιστρέφει μια τυχαία καθυστέρηση από 2 έως 4 sec
     */

    private void delay() throws InterruptedException {
        Random rand = new Random();
        Thread.sleep(rand.nextInt(2000) + 2001);
    }

    //μέθοδος που διατρέχει την λίστα αιτήσεων για πρώτη φορά
    private void processSubmittedRequests() {

        try {
            final List<Reservation> tobeRemoved = new ArrayList<Reservation>();
            int listSize = requestList.getModel().getSize();

            for (int i = 0; i < listSize; i++) {

                final Reservation r = (Reservation) requestList.getModel().getElementAt(i);

                //τσεκάρει μόνο για τις αιτήσεις που είναι σε κατάσταση Υποβλήθηκε 
                if (r.getStatusId() == 2) {

                    //αν η λίστα επιβεβαιωμένων κρατήσεων είναι γεμάτη
                    if (confirmedList.getModel().getSize() == 10) {
                        System.out.println("Δεν υπάρχει διαθέσιμη θέση");
                        //θέτει την κατάσταση σε μη-διαθέσιμη                    
                        r.setStatusId(Short.valueOf("4"));
                        tobeRemoved.add(r);

                        if (r == reservation) {
                            resView.statusLabel.setText("ΜΗ ΔΙΑΘΕΣΙΜΗ");
                            resView.statusPanel.setBackground(Color.RED);
                        }
                    }

                    //αν η λίστα των επιβεβαιωμένων δεν είναι γεμάτη αλλά είναι γεμάτη των μη-επιβεβαιωμένων
                    if (confirmedList.getModel().getSize() < 10 && pendingList.getModel().getSize() == 10) {
                        //θέτει την κατάσταση σε λίστα αναμονής
                        r.setStatusId(Short.valueOf("3"));

                        if (r == reservation) {
                            resView.statusLabel.setText("ΛΙΣΤΑ ΑΝΑΜΟΝΗΣ");
                            resView.statusPanel.setBackground(Color.PINK);
                        }

                    }

                    /*αν οι λίστες επιβεβαιωμένων και μη-επιβεβαιωμένων δεν είναι γεμάτες
                     * τότε την μεταφέρει από την λίστα αιτήσεων στην λίστα μη επιβεβαιωμένων 
                     */
                    if (confirmedList.getModel().getSize() < 10 && pendingList.getModel().getSize() < 10) {
                        //  System.out.println("frqAdding to pendingList: " + r);                                      
                        r.setStatusId(Short.valueOf("5"));
                        tobeRemoved.add(r);

                        SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {
                                GeneralListModel pendingModel = (GeneralListModel) pendingList.getModel();
                                pendingModel.addReservation(r);
                                pendingList.updateUI();
                            }
                        });

                        if (r == reservation) {
                            reservation.setStatusId(Short.valueOf("5"));
                            resView.statusLabel.setText("ΔΙΑΘΕΣΙΜΗ");
                            resView.statusPanel.setBackground(Color.YELLOW);
                            resView.confirmButton.setEnabled(true);
                        }
                    }
                }
            }

            // Διαγράφει τις αιτήσεις που έχουν γίνει διαθέσιμες από την λίστα των αιτήσεων
            SwingUtilities.invokeAndWait(new Runnable() {

                public void run() {
                    for (final Reservation reservation : tobeRemoved) {
                        ReservationRequestsListModel requestsModel = (ReservationRequestsListModel) requestList.getModel();
                        requestsModel.removeReservation(reservation);
                        requestList.updateUI();
                    }
                }
            });


        } catch (InterruptedException ie) {
            ie.printStackTrace();
        } catch (InvocationTargetException ite) {
            ite.printStackTrace();
        }


    }

    //μέθοδος που διατρέχει την λίστα μη-επιβεβαιωμένων αιτήσεων 
    public void processRequestsPendingApproval() {

        try {
            final List<Reservation> tobeRemoved = new ArrayList<Reservation>();
            int listSize = pendingList.getModel().getSize();


            for (int i = 0; i < listSize; i++) {

                final Reservation r = (Reservation) pendingList.getModel().getElementAt(i);

                //αν η λίστα επιβεβαιωμένων έχει θέσεις
                if (confirmedList.getModel().getSize() < 10) {
                    //αν η αίτηση έχει επιβεβαιωθεί την προσθέτει στην λίστα των επιβεβαιωμένων
                    if (r.getStatusId() == 6) {

                        System.out.println("Adding to confirmedList: " + r);
                        SwingUtilities.invokeAndWait(new Runnable() {

                            /*αλλάζει την κατάσταση σε ΕΠΙΒΕΒΑΙΩΘΗΚΕ την προσθέτει στην λίστα των επιβεβαιωμένων
                             * και την αποθηκεύει στην βάση.
                             */
                            public void run() {
                                r.setStatusId(Short.valueOf("8"));
                                GeneralListModel model = (GeneralListModel) confirmedList.getModel();
                                model.addReservation(r);
                                dBm.storeReservation(r);

                            }
                        });
                        // την προσθετεί στην λίστα που είναι ια διαγραφή(από την λίστα των μη-επιβεβαιωμένων)
                        tobeRemoved.add(r);
                        System.out.println("Η κράτηση εγκρίθηκε!");
                        //και ενημερώνει το παράθυρο της αίτησης
                        if (r == reservation) {
                            resView.statusLabel.setText("ΕΠΙΒΕΒΑΙΩΘΗΚΕ");
                            resView.statusPanel.setBackground(Color.GREEN);
                            resView.confirmButton.setEnabled(false);
                            resView.createReservButton.setEnabled(false);
                            resView.saveReservButton.setEnabled(true);
                        }

                    } /*αλλιώς την θέτει σε κατάσταση Ακυρωσης και την προσθέτη στην λίστα που έχουμε 
                     * δημιουργήσει για τις πρός διαγραφή αιτήσεις
                     */ else {
                        r.setStatusId(Short.valueOf("7"));
                        tobeRemoved.add(r);

                        /*αν αυτή η κράτηση είναι του χρήστη που έιναι στην εφαρμογή (δεν είναι από τις τυχαίες δηλαδή)
                         * άλλαξε στο παράθυρο της αίτησης την κατάσταση και το χρώμα και τοκουμπί επιβεβαιώση ανενεργό. 
                         */

                        if (r == reservation) {
                            resView.statusLabel.setText("ΑΚΥΡΩΘΗΚΕ");
                            resView.statusPanel.setBackground(Color.ORANGE);
                            resView.confirmButton.setEnabled(false);
                        }
                    }
                } //αλλιώς αν η λίστα των επιβεββαιωμένων αιτήσεων είναι πλήρης ακυρωνει την αίτηση    
                else {
                    r.setStatusId(Short.valueOf("7"));
                    tobeRemoved.add(r);

                    if (r == reservation) {
                        resView.statusLabel.setText("ΑΚΥΡΩΘΗΚΕ");
                        resView.statusPanel.setBackground(Color.ORANGE);
                        resView.confirmButton.setEnabled(false);
                    }
                }
            }

            // Διαγράφη τις επιβεβαιωμένες πλέον αιτήσεις από την λίστα των μη-επιβεβαιωμένων
            SwingUtilities.invokeAndWait(new Runnable() {

                public void run() {
                    for (final Reservation reservation : tobeRemoved) {
                        GeneralListModel reservModel = (GeneralListModel) pendingList.getModel();
                        //reservModel.reservations.removeAll(tobeRemoved);

                        reservModel.removeReservation(reservation);
                        pendingList.updateUI();
                    }
                }
            });


        } catch (InterruptedException ie) {
            ie.printStackTrace();
        } catch (InvocationTargetException ite) {
            ite.printStackTrace();
        }
    }
    //μέθοδος που διατρέχει την λίστα αιτήσεων για δεύτερη φορά

    public void processRequestsInAwaitingListStatus() {

        try {
            final List<Reservation> tobeRemoved = new ArrayList<Reservation>();
            int listSize = requestList.getModel().getSize();

            for (int i = 0; i < listSize; i++) {

                final Reservation r = (Reservation) requestList.getModel().getElementAt(i);
                //τσεκάρει μόνο για τις αιτήσεις που είναι σε κατάσταση Λίστα αναμονής
                if (r.getStatusId() == 3) {
                    /**
                     * αν η λίστα μη-επιβεβαιωμένων δεν είναι γεμάτη
                     * τότε την μεταφέρει από την λίστα αιτήσεων στην λίστα μη επιβεβαιωμένων 
                     */
                    if (pendingList.getModel().getSize() < 10) {

                        r.setStatusId(Short.valueOf("5"));
                        SwingUtilities.invokeAndWait(new Runnable() {

                            public void run() {
                                GeneralListModel model = (GeneralListModel) pendingList.getModel();
                                model.addReservation(r);
                            }
                        });

                        tobeRemoved.add(r);
                        //αλλάζει το παράθυρο των αιτήσεων
                        if (r == reservation) {
                            resView.statusLabel.setText("ΔΙΑΘΕΣΙΜΗ");
                            resView.statusPanel.setBackground(Color.YELLOW);
                            resView.confirmButton.setEnabled(true);
                        }
                    }
                }
            }


            // Διαγράφει τις ΔΙΑΘΕΣΙΜΕΣ πλέον αιτήσεις από την λίστα των αιτήσεων
            SwingUtilities.invokeAndWait(new Runnable() {

                public void run() {
                    for (final Reservation reservation : tobeRemoved) {
                        ReservationRequestsListModel reservModel = (ReservationRequestsListModel) requestList.getModel();
                        reservModel.removeReservation(reservation);
                        pendingList.updateUI();
                    }
                }
            });


        } catch (InterruptedException ie) {
//            ie.printStackTrace();
        } catch (InvocationTargetException ite) {
//            ite.printStackTrace();
        }
    }

    // Διαγράφει ένα τυχαίο αριθμό από την λίστα των επιβεββαιωμένων κρατήσεων και από την βάση
    public void deleteRandomNumOfComfirmedReservation() {
        //αν  υπάρχουν επιβεβαιωμένες κρατήσεις
        if (confirmedList.getModel().getSize() > 0) {
            //δημιουργησε ένα τυχαίο αριθμό
            int max = generateRandomNumber(0, confirmedList.getModel().getSize());

            final List<Reservation> tobeRemoved = new ArrayList<Reservation>();
            //και διέγραψε τόσες κρατήσεις όσες είναι ο αριθμός που δημιούργησες παραπάνω
            for (int i = 0; i < max; i++) {

                GeneralListModel model = (GeneralListModel) confirmedList.getModel();
                Reservation r = (Reservation) model.getElementAt(i);
                tobeRemoved.add(r);
                dBm.removeReservation(r);
            }

            try {
                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {
                        GeneralListModel reservModel = (GeneralListModel) confirmedList.getModel();
                        reservModel.reservations.removeAll(tobeRemoved);

                    }
                });
            } catch (InterruptedException ex) {
                Logger.getLogger(ReservSystem.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvocationTargetException ex) {
                Logger.getLogger(ReservSystem.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
    }

    /*Δημιουργία μη επιβεβαιωμένων τυχαίων κρατήσεων
     * @return Την λίστα με τις τυχαίες αιτήσεις που έχουμε δημιουργήσει
     */
    private List<Reservation> generateUnconfirmedReservations() {
        //η λίστα που θα γεμίσει με τις τυχαίες αιτήσεις κρατήσεων που θα δημιουργήσουμε
        List<Reservation> unconfirmedList = new ArrayList<Reservation>();
        //αν έχει χ'ωρο στην λίστα των αιτήσεων (max = 20 αιτήσεις)
        if (requestList.getModel().getSize() < 20) {
            //δημιουργησε ενα τυχαίο αριθμό αιτήσεων αναμεσα στον ελέυθερο χώρο    
            int max = generateRandomNumber(1, 20 - requestList.getModel().getSize());
            //γεμίζουμε δυο λίστες με τα εστιατορια και τους χρηστες απο την βάση
            List<Restaurant> restaurants = dBm.retrieveAllRests();
            List<User> users = dBm.retrieveAllUsers();
            //και για όσες φορές έχουμε βρε παραπάνω δημιουργησε αιτήσεις
            for (int i = 1; i <= max; i++) {
                //επιλέγει από την λίστα των εστιατορίων ένα τυχαίο 
                int restaurantIndex = generateRandomNumber(0, restaurants.size() - 1);
                Restaurant r = restaurants.get(restaurantIndex);
                //και επιλέγει και από την λίστα των χρηστών ένα τυχαίο
                int userIndex = generateRandomNumber(0, users.size() - 1);
                String username = users.get(userIndex).getUsername();
                //και δημιουργεί μια αίτηση κράτησης
                Reservation res = new Reservation(r.getId(), r.getRestName(), username, new Date(), Short.valueOf("2"));
                //την προσθέτουμε στην λίστα με τις αιτήσεις 
                unconfirmedList.add(res);
            }
        }
        //επιστρεφουμε την λίστα με τις τυχαίες αιτήσεις πιυ δημιουργήσαμε
        return unconfirmedList;
    }
    /*Μεθοδος που επιστρέφει όλες τις κράτησεις που υπάρχουν στην βάση
     * @return την λίστα με τις κρατήσεις
     */

    private List<Reservation> retrieveAllComfirmedReservation() {

        List<Reservation> confirmedList = new ArrayList<Reservation>();
        confirmedList = dBm.retrieveAllRerervations();

        return confirmedList;
    }
    //inner κλάση για το μοντελο για τις λίστα αιτήσεων

    class ReservationRequestsListModel extends DefaultListModel {

        private List<Reservation> reservations = new ArrayList<Reservation>();

        public ReservationRequestsListModel() {
            super();
            System.out.println(reservations);
        }

        public int getSize() {
            return reservations.size();
        }

        public Object getElementAt(int i) {
            return reservations.get(i);
        }

        public void addReservation(Reservation x) {
            reservations.add(x);
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }

        public void removeReservation(Reservation x) {
            reservations.remove(x);
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }

        public void updateModel() {
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }
    } // end class
    //inner class για το μοντέλο των μη-επιβεβαιωμένων και επιβεβαιωμένων λιστών κρατήσεων

    class GeneralListModel extends DefaultListModel {

        private List<Reservation> reservations = new ArrayList<Reservation>();

        public GeneralListModel() {
        }

        public int getSize() {
            return reservations.size();
        }

        public Object getElementAt(int i) {
            return reservations.get(i);
        }

        public void addReservation(Reservation x) {
            reservations.add(x);
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }

        public void removeReservation(Reservation x) {
            reservations.remove(x);
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }

        public void updateModel() {
            fireContentsChanged(this, reservations.size() - 1, reservations.size() - 1);
        }
    }

    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jLabel1 = new javax.swing.JLabel();
        jLabel2 = new javax.swing.JLabel();
        jScrollPane1 = new javax.swing.JScrollPane();
        requestList = new javax.swing.JList();
        jLabel3 = new javax.swing.JLabel();
        jScrollPane2 = new javax.swing.JScrollPane();
        pendingList = new javax.swing.JList();
        jLabel4 = new javax.swing.JLabel();
        jScrollPane3 = new javax.swing.JScrollPane();
        confirmedList = new javax.swing.JList();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        org.jdesktop.application.ResourceMap resourceMap = org.jdesktop.application.Application.getInstance(handax.HandaxApp.class).getContext().getResourceMap(ReservSystem.class);
        setTitle(resourceMap.getString("Form.title")); // NOI18N
        setLocation(new java.awt.Point(900, 22));
        setName("Form"); // NOI18N

        jLabel1.setFont(resourceMap.getFont("jLabel1.font")); // NOI18N
        jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        jLabel1.setText(resourceMap.getString("jLabel1.text")); // NOI18N
        jLabel1.setName("jLabel1"); // NOI18N

        jLabel2.setFont(resourceMap.getFont("jLabel2.font")); // NOI18N
        jLabel2.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        jLabel2.setText(resourceMap.getString("jLabel2.text")); // NOI18N
        jLabel2.setName("jLabel2"); // NOI18N

        jScrollPane1.setName("jScrollPane1"); // NOI18N

        requestList.setName("requestList"); // NOI18N
        jScrollPane1.setViewportView(requestList);

        jLabel3.setFont(resourceMap.getFont("jLabel3.font")); // NOI18N
        jLabel3.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        jLabel3.setText(resourceMap.getString("jLabel3.text")); // NOI18N
        jLabel3.setName("jLabel3"); // NOI18N

        jScrollPane2.setName("jScrollPane2"); // NOI18N

        pendingList.setName("pendingList"); // NOI18N
        jScrollPane2.setViewportView(pendingList);

        jLabel4.setFont(resourceMap.getFont("jLabel4.font")); // NOI18N
        jLabel4.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
        jLabel4.setText(resourceMap.getString("jLabel4.text")); // NOI18N
        jLabel4.setName("jLabel4"); // NOI18N

        jScrollPane3.setName("jScrollPane3"); // NOI18N

        confirmedList.setName("confirmedList"); // NOI18N
        jScrollPane3.setViewportView(confirmedList);

        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .addContainerGap()
                .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
                    .add(jScrollPane1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(jScrollPane2, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(jScrollPane3, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(jLabel3, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(jLabel4, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(jLabel1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE)
                    .add(org.jdesktop.layout.GroupLayout.TRAILING, jLabel2, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 364, Short.MAX_VALUE))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .add(20, 20, 20)
                .add(jLabel1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, 28, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jLabel2)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jScrollPane1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jLabel3)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jScrollPane2, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jLabel4)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jScrollPane3, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(52, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JList confirmedList;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JScrollPane jScrollPane3;
    private javax.swing.JList pendingList;
    private javax.swing.JList requestList;
    // End of variables declaration//GEN-END:variables
}
